# ==============================================
# 导入层
# ==============================================
from . import config as config_module               # 导入配置模块中的全局变量
from .Android_intent import open_uri_activity       # 导入Android_intent模块
from ascript.android.screen import FindColors       # 导入颜色识别模块
from .lanying_HID import BlueHid                    # 导入已加载的蓝影键鼠模块
from ascript.android.system import Device           # 获取系统信息
import time                                         # 时间操作模块（用于延时、计时等）
from ascript.android.node import Selector           # 导AS控件包（用于安卓界面控件选择操作）
import re                                           # 添加正则表达式模块导入
import pandas as pd                                 # 添加pandas库导入
from .Dialogue_collection import process_xiaohongshu_chat                  # 导入对话收集模块




# ==============================================
# 封装层
# ==============================================

# 获取屏幕信息
display = Device.display()
# 屏幕宽度
wide = display.widthPixels
# 屏幕高度
High = display.heightPixels

# 封装蓝牙HID键鼠控件实现稳当滑动
def scroll_screen(direction='up', scroll_pixels=300, press_delay=100, scroll_duration=3000, lift_delay=50):
    """控制蓝牙键鼠执行像素级滚动操作
    参数：
        direction: str 滚动方向，可选 'up'（上滑）/'down'（下滑）
        scroll_pixels: 滚动像素数（默认300像素）
        press_delay: int 按下延迟（单位：毫秒，默认0 建议写0,如果想拖动,可以写50~100）
        scroll_duration: int 滚动持续时间（单位：毫秒，根据像素动态计算)
        lift_delay: int 抬起延迟（单位：毫秒，默认0 建议写0写10~50 不写默认0）
    返回：
        None 通过蓝牙HID直接控制设备操作
    """
    # 参数有效性检查
    if direction not in ['up', 'down']:
        print(f"警告：{direction} 不是有效方向，默认使用'up'")
        direction = 'up'

    # 动态计算滚动时长（每像素5ms的滑动速度）
    # scroll_duration = int(scroll_pixels * 5)

    start_x = int(wide * 0.5)
    start_y = int(High * 0.5)

    # 根据方向计算终止坐标
    if direction == 'up':
        end_y = start_y - scroll_pixels
    else:
        end_y = start_y + scroll_pixels  # 向下滑动时增加Y坐标值

    # 执行蓝牙HID滚动操作（使用蓝影智连模块）
    BlueHid.swipEx(
        start_x, start_y,  # 起始坐标（屏幕正中心）
        start_x, end_y,  # 终止坐标（Y轴偏移）
        press_delay,  # 参数化按下延迟
        scroll_duration,  # 动态计算的滚动持续时间
        lift_delay  # 参数化抬起延迟
    )

# 打开小红书消息页，并回到顶部
def Open_message_page(count=10):
    # 打开小红书消息页面
    web_window=open_uri_activity("xhsdiscover://messages")

    #延时
    time.sleep(3) 

    found_top_page = False          # 是否找到顶部

    if web_window:
        print("[处理常规消息] 打开小红书消息页面成功")

        top_attempts = count               # 检查顶部的最大尝试次数
        top_current_attempt = 0            # 计数

        while top_current_attempt < top_attempts:

            #找顶部"新增关注"
            interaction_rec=Selector(6).text("新增关注").find()

            if interaction_rec: 
                print(f"[处理常规消息] 已在消息页面顶部，可以进行下一步... (共尝试{top_current_attempt+1}次)")

                found_top_page = True
                return found_top_page   # 传出数据
                break                   # 找到所有节点，退出循环

            else:
                print("[处理常规消息] 未找到顶部，尝试上滑屏幕")

                # 快速向下滑屏
                BlueHid.swipM(int(wide / 2), int(High / 2-600), int(wide / 2), int(High / 2))
                time.sleep(2)  # 稍微延长等待时间，确保页面稳定

                top_current_attempt += 1   #计数加1
        
        # 如果超出最大尝试次数仍未找到元素，返回False
        if top_current_attempt >= top_attempts:
            print(f"[处理常规消息] 已达到最大尝试次数({top_attempts}次)，未能找到顶部元素")
            return False

    else:
        print("[处理常规消息] 打开小红书消息页面失败")
        
    return found_top_page   # 传出数据

# 识别和提取当前屏幕中的个人消息
def extract_message_list():
    """
    获取小红书消息列表并整理到DataFrame
    
    返回:
        DataFrame: 包含昵称、最新对话内容、未读消息条数、时间、控件对象的表格
    """
    # 创建空DataFrame
    columns = ['昵称', '最新对话内容', '未读消息条数', '时间', '控件对象']
    messages_df = pd.DataFrame(columns=columns)
    

    # 获取全部未读消息列表项
    unread_items = Selector().type("ViewGroup").desc("未读").find_all()
    
    # 添加空值检查
    if unread_items is None:
        print("[处理常规消息] 未找到任何未读消息")
        unread_items = []  # 设为空列表以避免后续错误
    
    # 用于存储个人消息的列表
    personal_messages = []
    
    # # 打印所有原始消息，便于分析
    # print("===== 全部消息项 =====")
    # for item in unread_items:
    #     if hasattr(item, 'desc') and item.desc:    # 判断是否存在desc属性(文本描述)
    #         print(f"原始消息: {item.desc}")
    # print("=====================")
    
    for message_item in unread_items:
        try:
            # 获取消息项的描述文本
            if not hasattr(message_item, 'desc') or not message_item.desc:  # 判断是否存在desc属性(文本描述)
                
                continue  # 如果消息项没有desc属性，则跳过
                
            desc_text = message_item.desc      # 获取消息项的描述文本
            
            # 标准化分隔符 - 将英文逗号转换为中文逗号
            normalized_text = desc_text.replace(',', '，')          # 将英文逗号转换为中文逗号
            parts = normalized_text.split('，')                     # 将描述文本按中文逗号分割
            
            # 确保有足够的部分
            if len(parts) < 4:  # 至少需要4部分：昵称、未知、未读状态、内容、时间
                print(f"[处理常规消息] 消息内容构造部分不足，跳过消息: {desc_text}")
                
                continue  # 如果消息项没有足够的部分，则跳过
            
            # 1. 提取昵称 (第一部分)
            nickname = parts[0].strip()
            
            # 2. 提取第三部分（关键部分，用于判断是否为个人消息）
            third_part = parts[2].strip() if len(parts) > 2 else ""
            
            # 3. 严格按照用户要求判断是否为个人消息
            is_personal = False
            unread_count = 0
            
            # 严格判断标准：第三部分为空或包含"条未读"
            if third_part == "":
                is_personal = True
            elif "条未读" in third_part:
                is_personal = True
                # 提取未读数量
                match = re.search(r'(\d+)条未读', third_part)
                if match:
                    unread_count = int(match.group(1))
            
            # 4. 提取时间 (最后一部分)
            time = parts[-1].strip()
            
            # 5. 提取消息内容 (第四部分到倒数第二部分)
            content_parts = []
            if len(parts) >= 5:  # 确保至少有5个部分
                content_parts = parts[3:-1]  # 从第四部分到倒数第二部分
            elif len(parts) == 4:  # 只有4个部分时
                content_parts = [parts[3]]  # 只取第四部分
                
            content = '，'.join(content_parts) if content_parts else "无内容"
            
            # 只添加判定为个人消息的项
            if is_personal:
                personal_messages.append({
                    '昵称': nickname,
                    '最新对话内容': content,
                    '未读消息条数': unread_count,
                    '时间': time,
                    '控件对象': message_item
                })

            # #     #简化输出，只在调试时需要打开
            #     print(f"[处理常规消息] 找到个人消息: {nickname} | 第三部分:[{third_part}] | 内容: {content} | 时间: {time}")
            # # else:
            #     print(f"[处理常规消息] 非个人消息: {nickname} | 第三部分:[{third_part}] | 内容: {content}")
        
        except Exception as e:
            print(f"[处理常规消息] 处理消息时出错: {str(e)}, 消息内容: {desc_text if 'desc_text' in locals() else '未知'}")
    
    # 将个人消息列表转换为DataFrame
    if personal_messages:
        messages_df = pd.DataFrame(personal_messages)
        print(f"[处理常规消息] 识别到 {len(messages_df)} 条个人消息")
    else:
        print("[处理常规消息] 未找到符合条件的个人消息")
    
    return messages_df



#处理小红书应用中的常规未读消息
def process_unread_xiaohongshu_messages():
    """
    处理小红书应用中的常规未读消息
    
    该函数会自动滚动消息列表，找到并处理所有未读消息。处理包括点击进入聊天，
    截取聊天记录，调用工作流进行处理，然后返回消息列表。循环次数由max_process_cycles控制。
        
    返回:
        int: 成功处理的未读消息总数
    """
    # 确保进入消息页面顶部
    Open_message_page(10)
    
    processed_count = 0                                      # 记录处理的消息总数
    max_process_cycles=int(config_module.messages_page)      # 消息查询页数

    for cycle in range(max_process_cycles):
        print(f"[处理常规消息] 第 {cycle+1}/{max_process_cycles} 轮消息处理")

        # 查询控件范围
        message_RecyclerView = Selector(6).type("RecyclerView").depth(15).find()
        
        # 添加空值检查
        if message_RecyclerView is None:
            print("[处理常规消息] 未找到消息列表控件")
            
            return 0  # 或采取其他适当的操作
        
        # 获取当前消息控件的位置信息
        View_Range = message_RecyclerView.rect  # 获取控件范围值
        y_01 = View_Range.top
        y_02 = View_Range.bottom


        # 调用函数获取当前屏幕的消息列表（个人消息）
        personal_messages_df = extract_message_list()
        
        # 筛选未读消息条数大于0的记录
        filtered_df = personal_messages_df[personal_messages_df['未读消息条数'] > 0]

        # 进一步筛选出在可见区域内的未读消息
        visible_messages = []
        for idx, row in filtered_df.iterrows():         
            control = row['控件对象']
            control_rect = control.rect

            # 检查控件是否完全在可见范围内
            if control_rect.top >= y_01 and control_rect.bottom <= y_02:
                visible_messages.append(row)
        
        # 将可见的未读消息转换为新的DataFrame
        visible_df = pd.DataFrame(visible_messages) if visible_messages else pd.DataFrame(columns=filtered_df.columns)

        # 根据是否有可见的未读消息，执行不同的操作
        if not visible_df.empty:
            print(f"[处理常规消息] 发现 {len(filtered_df)} 条未读消息，其中 {len(visible_df)} 条在可见区域")

            # 遍历可见区域内的未读消息
            for count, (index, row) in enumerate(visible_df.iterrows(), 1):
                Unread_events = row['控件对象']
                # 打印处理信息
                print(f"[处理常规消息] 开始处理第 {count}/{len(visible_df)} 条未读消息，用户昵称：{row['昵称']}")
                
                # 点击未读事件
                BlueHid.click(Unread_events.center_x, Unread_events.center_y)

                time.sleep(3)  # 必须等待画面稳定后再操作

                # 调用未读消息处理功能
                process_xiaohongshu_chat()

                

                # # 测试用，直接返回True
                # result = True

                # 计数
                processed_count += 1

                # # 按返回键(process_xiaohongshu_chat自带返回，仅测试时打开)
                # BlueHid.back()

                time.sleep(3)  # 必须等待画面稳定后再操作
        else:
            print("[处理常规消息] 本轮没有发现可见区域内的未读消息")

        # 向下稳定滑动一屏 - 无论是否有未读消息都执行滑动
        print("[处理常规消息] 执行向下滑动，寻找更多未读消息...")
        scroll_screen('up', 800, 100, 3000, 50)

        # 如果不是最后一轮，等待一段时间再开始下一轮
        if cycle < max_process_cycles - 1:
            print(f"[处理常规消息] 第 {cycle+1} 轮处理完成，等待3秒开始下一轮...")
            time.sleep(3)
    
    print(f"[处理常规消息] 完成，共处理 {processed_count} 条未读消息")
    return processed_count
#==============================================
# 主程序
#==============================================
if __name__ == "__main__":

    # 调用函数
    process_unread_xiaohongshu_messages()

    
